*
* Creates a #PangoContext for the default GDK screen.
*
- * The context must be freed when you're finished with it.
+ * The context must be freed when you’re finished with it.
*
* When using GTK+, normally you should use gtk_widget_get_pango_context()
* instead of this function, to get the appropriate context for
*
* Creates a #PangoContext for @screen.
*
- * The context must be freed when you're finished with it.
+ * The context must be freed when you’re finished with it.
*
* When using GTK+, normally you should use gtk_widget_get_pango_context()
* instead of this function, to get the appropriate context for
* obscured/offscreen regions to be placed in the pixbuf. The contents of
* portions of the pixbuf corresponding to the offscreen region are undefined.
*
- * If the window you're obtaining data from is partially obscured by
+ * If the window you’re obtaining data from is partially obscured by
* other windows, then the contents of the pixbuf areas corresponding
* to the obscured regions are undefined.
*
* For example, a visual might support 24-bit color, or 8-bit color,
* and might expect pixels to be in a certain format.
*
- * Call g_list_free() on the return value when you're finished with it.
+ * Call g_list_free() on the return value when you’re finished with it.
*
* Return value: (transfer container) (element-type GdkVisual):
* a list of visuals; the list must be freed, but not its contents
* on very high density outputs this can be a higher value (often 2).
*
* This can be used if you want to create pixel based data for a
- * particula monitor, but most of the time you're drawing to a window
+ * particula monitor, but most of the time you’re drawing to a window
* where it is better to use gdk_window_get_scale_factor() instead.
*
* Since: 3.10
* For example, a visual might support 24-bit color, or 8-bit color,
* and might expect pixels to be in a certain format.
*
- * Call g_list_free() on the return value when you're finished with it.
+ * Call g_list_free() on the return value when you’re finished with it.
*
* Return value: (transfer container) (element-type GdkVisual):
* a list of visuals; the list must be freed, but not its contents
*
* Obtains the parent of @window, as known to GDK. Does not query the
* X server; thus this returns the parent as passed to gdk_window_new(),
- * not the actual parent. This should never matter unless you're using
+ * not the actual parent. This should never matter unless you’re using
* Xlib calls mixed with GDK calls on the X11 platform. It may also
* matter for toplevel windows, because the window manager may choose
* to reparent them.
*
* When using GTK+, the widget system automatically places calls to
* gdk_window_begin_paint_region() and gdk_window_end_paint() around
- * emissions of the expose_event signal. That is, if you're writing an
+ * emissions of the expose_event signal. That is, if you’re writing an
* expose event handler, you can assume that the exposed area in
* #GdkEventExpose has already been cleared to the window background,
* is already set as the clip region, and already has a backing store.
* This can be used to record the invalidated region, which is
* useful if you are keeping an offscreen copy of some region
* and want to keep it up to date. You can also modify the
- * invalidated region in case you're doing some effect where
+ * invalidated region in case you’re doing some effect where
* e.g. a child widget appears in multiple places.
*
* Since: 3.10
* anyway, instead of using GDK functions. For child windows,
* the move will reliably succeed.
*
- * If you're also planning to resize the window, use gdk_window_move_resize()
+ * If you’re also planning to resize the window, use gdk_window_move_resize()
* to both move and resize simultaneously, for a nicer visual effect.
**/
void
*
* Windows may not be resized below 1x1.
*
- * If you're also planning to move the window, use gdk_window_move_resize()
+ * If you’re also planning to move the window, use gdk_window_move_resize()
* to both move and resize simultaneously, for a nicer visual effect.
**/
void
*
* Sets the background color of @window. (However, when using GTK+,
* set the background of a widget with gtk_widget_modify_bg() - if
- * you're an application - or gtk_style_set_background() - if you're
+ * you’re an application - or gtk_style_set_background() - if you're
* implementing a custom widget.)
*
* See also gdk_window_set_background_pattern().
* window manager to do things like center @window on @parent and
* keep @window above @parent.
*
- * See gtk_window_set_transient_for() if you're using #GtkWindow or
+ * See gtk_window_set_transient_for() if you’re using #GtkWindow or
* #GtkDialog.
**/
void
* Sets a function to be used for translating the @label and @tooltip of
* #GtkActionEntry<!-- -->s added by gtk_action_group_add_actions().
*
- * If you're using gettext(), it is enough to set the translation domain
+ * If you’re using gettext(), it is enough to set the translation domain
* with gtk_action_group_set_translation_domain().
*
* Since: 2.4
* @label and @tooltip of #GtkActionEntry<!-- -->s added by
* gtk_action_group_add_actions().
*
- * If you're not using gettext() for localization, see
+ * If you’re not using gettext() for localization, see
* gtk_action_group_set_translate_func().
*
* Since: 2.4
* impossible to know in advance whether they will end up empty after merging.
* #GtkUIManager offers two ways to treat empty submenus:
*
- * - make them disappear by hiding the menu item they're attached to
+ * - make them disappear by hiding the menu item they’re attached to
*
* - add an insensitive “Empty” item
*
*
* Note that “accelerators” are different from
* “mnemonics”. Accelerators are shortcuts for
- * activating a menu item; they appear alongside the menu item they're a
+ * activating a menu item; they appear alongside the menu item they’re a
* shortcut for. For example “Ctrl+Q” might appear alongside the “Quit”
* menu item. Mnemonics are shortcuts for GUI elements such as text
* entries or buttons; they appear as underlined characters. See
* Accelerator maps are used to define runtime configurable accelerators.
* Functions for manipulating them are are usually used by higher level
* convenience mechanisms like #GtkUIManager and are thus considered
- * “low-level”. You’ll want to use them if you're manually creating menus that
+ * “low-level”. You’ll want to use them if you’re manually creating menus that
* should have user-configurable accelerators.
*
* An accelerator is uniquely defined by:
* gtk_cell_renderer_toggle_get_radio:
* @toggle: a #GtkCellRendererToggle
*
- * Returns whether we're rendering radio toggles rather than checkboxes.
+ * Returns whether we’re rendering radio toggles rather than checkboxes.
*
- * Return value: %TRUE if we're rendering radio toggles rather than checkboxes
+ * Return value: %TRUE if we’re rendering radio toggles rather than checkboxes
**/
gboolean
gtk_cell_renderer_toggle_get_radio (GtkCellRendererToggle *toggle)
* GtkDeleteType:
* @GTK_DELETE_CHARS: Delete characters.
* @GTK_DELETE_WORD_ENDS: Delete only the portion of the word to the
- * left/right of cursor if we're in the middle of a word.
+ * left/right of cursor if we’re in the middle of a word.
* @GTK_DELETE_WORDS: Delete words.
* @GTK_DELETE_DISPLAY_LINES: Delete display-lines. Display-lines
* refers to the visible lines, with respect to to the current line
* Retrieves the name of the currently selected font. This name includes
* style and size information as well. If you want to render something
* with the font, use this string with pango_font_description_from_string() .
- * If you're interested in peeking certain values (family name,
+ * If you’re interested in peeking certain values (family name,
* style, size, weight) just query these properties from the
* #PangoFontDescription object.
*
* Markup strings are just a convenient way to set the #PangoAttrList on
* a label; gtk_label_set_attributes() may be a simpler way to set
* attributes in some cases. Be careful though; #PangoAttrList tends to
- * cause internationalization problems, unless you're applying attributes
+ * cause internationalization problems, unless you’re applying attributes
* to the entire string (i.e. unless you set the range of each attribute
* to [0, %G_MAXINT)). The reason is that specifying the start_index and
* end_index for a #PangoAttribute requires knowledge of the exact string
* and doesn’t do anything but paint a blank background by default. It's
* different in that it supports scrolling natively (you can add it to a
* #GtkScrolledWindow), and it can contain child widgets, since it’s a
- * #GtkContainer. However if you're just going to draw, a #GtkDrawingArea
+ * #GtkContainer. However if you’re just going to draw, a #GtkDrawingArea
* is a better choice since it has lower overhead.
*
* When handling expose events on a #GtkLayout, you must draw to
*
* Returns the printer’s capabilities.
*
- * This is useful when you're using #GtkPrintUnixDialog’s manual-capabilities
+ * This is useful when you’re using #GtkPrintUnixDialog’s manual-capabilities
* setting and need to know which settings the printer can handle and which
* you must handle yourself.
*
* refers to the _sending_ part of the INCR protocol. The receiving
* portion is referred to just as “retrieval”. (Terminology borrowed
* from Tk, because there is no good opposite to “retrieval” in English.
- * “send” can’t be made into a noun gracefully and we're already using
+ * “send” can’t be made into a noun gracefully and we’re already using
* “emission” for something else ....)
*/
* GTK_STYLE_CLASS_SCROLLBARS_JUNCTION:
*
* A CSS class to match the junction area between an horizontal
- * and vertical scrollbar, when they're both shown.
+ * and vertical scrollbar, when they’re both shown.
*
* This is used in #GtkScrolledWindow.
*/
* (@left_gravity = %FALSE), the mark will end up on the right of
* newly-inserted text. The standard left-to-right cursor is a mark
* with right gravity (when you type, the cursor stays on the right
- * side of the text you're typing).
+ * side of the text you’re typing).
*
* The caller of this function does not own a
* reference to the returned #GtkTextMark, so you can ignore the
*
* Removes all tags in the range between @start and @end. Be careful
* with this function; it could remove tags added in code unrelated to
- * the code you're currently writing. That is, using this function is
+ * the code you’re currently writing. That is, using this function is
* probably a bad idea if you have two or more unrelated code sections
* that add tags.
**/
}
/* Goes back to the start of the next segment, even if
- * we're not at the start of the current segment (always
+ * we’re not at the start of the current segment (always
* ends up on a different segment if it returns TRUE)
*/
gboolean
* @rhs: another #GtkTextIter
*
* A qsort()-style function that returns negative if @lhs is less than
- * @rhs, positive if @lhs is greater than @rhs, and 0 if they're equal.
+ * @rhs, positive if @lhs is greater than @rhs, and 0 if they’re equal.
* Ordering is in character offset order, i.e. the first character in the buffer
* is less than the second character in the buffer.
*
* right gravity (@left_gravity = %FALSE), the mark will end up on the
* right of newly-inserted text. The standard left-to-right cursor is a
* mark with right gravity (when you type, the cursor stays on the right
- * side of the text you're typing).
+ * side of the text you’re typing).
*
* Return value: new #GtkTextMark
*
*
* Side effects:
* Toggle counts in the GtkTextBTreeNodes above the new line will be
- * updated if they're not already. Toggles may be collapsed
+ * updated if they’re not already. Toggles may be collapsed
* if there are duplicate toggles at the same position.
*
*--------------------------------------------------------------
/**
* gtk_tree_view_column_set_attributes:
* @tree_column: A #GtkTreeViewColumn
- * @cell_renderer: the #GtkCellRenderer we're setting the attributes of
+ * @cell_renderer: the #GtkCellRenderer we’re setting the attributes of
* @...: A %NULL-terminated list of attributes
*
* Sets the attributes in the list as the attributes of @tree_column.
*
* Computes the intersection of a @widget’s area and @area, storing
* the intersection in @intersection, and returns %TRUE if there was
- * an intersection. @intersection may be %NULL if you're only
+ * an intersection. @intersection may be %NULL if you’re only
* interested in whether there was an intersection.
*
* Return value: %TRUE if there was an intersection
#ifdef G_ENABLE_DEBUG
/* Verify invariants, see docs/widget_system.txt for notes on much of
- * this. Invariants may be temporarily broken while we're in the
+ * this. Invariants may be temporarily broken while we’re in the
* process of updating state, of course, so you can only
* verify_invariants() after a given operation is complete.
* Use push/pop_verify_invariants to help with that.
}
/* The point of this push/pop is that invariants may not hold while
- * we're busy making changes. So we only check at the outermost call
+ * we’re busy making changes. So we only check at the outermost call
* on the call stack, after we finish updating everything.
*/
static void
* directly, but from within a widget’s size_allocate method.
*
* The allocation set should be the “adjusted” or actual
- * allocation. If you're implementing a #GtkContainer, you want to use
+ * allocation. If you’re implementing a #GtkContainer, you want to use
* gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
* The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
* allocation inside gtk_widget_size_allocate() to create an adjusted
*
* Creates a new #GtkWindow, which is a toplevel window that can
* contain other widgets. Nearly always, the type of the window should
- * be #GTK_WINDOW_TOPLEVEL. If you're implementing something like a
+ * be #GTK_WINDOW_TOPLEVEL. If you’re implementing something like a
* popup menu from scratch (which is a bad idea, just use #GtkMenu),
* you might use #GTK_WINDOW_POPUP. #GTK_WINDOW_POPUP is not for
* dialogs, though in some other toolkits dialogs are called “popups”.
projects / gtk4.git / commitdiff